import { NextRequest, NextResponse } from 'next/server';
import { auth } from '@/auth';
import { prisma } from '@/lib/db';

/**
 * 处理文档自动保存请求
 */
export async function POST(
  request: NextRequest,
  { params }: { params: { id: string; documentId: string } }
) {
  try {
    console.log("自动保存API: 开始处理请求", params);
    
    // 验证用户身份
    const session = await auth();
    
    if (!session?.user) {
      console.log("自动保存API: 未授权访问");
      return NextResponse.json(
        { success: false, message: '未授权访问' },
        { status: 401 }
      );
    }
    
    const projectId = params.id;
    const documentId = params.documentId;
    console.log("自动保存API: 用户已认证", { 
      userId: session.user.id, 
      projectId, 
      documentId 
    });
    
    // 验证用户是否有权限编辑该文档
    const userMembership = await prisma.projectUser.findFirst({
      where: {
        projectId,
        userId: session.user.id,
        role: {
          in: ['OWNER', 'ADMIN', 'EDITOR'] // 添加EDITOR角色也可以编辑
        }
      }
    });
    
    if (!userMembership) {
      console.log("自动保存API: 权限检查失败", { userId: session.user.id });
      return NextResponse.json(
        { success: false, message: '您没有权限编辑此文档' },
        { status: 403 }
      );
    }
    
    // 解析请求体
    let body;
    try {
      body = await request.json();
    } catch (parseError) {
      console.error("自动保存API: 请求体解析失败", parseError);
      return NextResponse.json(
        { success: false, message: '请求体解析失败', error: String(parseError) },
        { status: 400 }
      );
    }
    
    const { content, version, createRevision = true } = body;
    console.log("自动保存API: 接收到内容", { 
      hasContent: !!content,
      version, 
      createRevision 
    });
    
    if (!content) {
      console.error("自动保存API: 内容为空");
      return NextResponse.json(
        { success: false, message: '缺少必要的内容字段' },
        { status: 400 }
      );
    }
    
    // 获取当前文档
    const document = await prisma.document.findUnique({
      where: { 
        id: documentId,
        projectId // 确保文档属于该项目
      }
    });
    
    if (!document) {
      console.log("自动保存API: 文档不存在", { documentId, projectId });
      return NextResponse.json(
        { success: false, message: '文档不存在' },
        { status: 404 }
      );
    }
    
    console.log("自动保存API: 当前文档信息", {
      id: document.id,
      title: document.title,
      currentVersion: document.version,
      requestVersion: version
    });
    
    // 检查版本冲突（如果提供了版本号）
    if (version && document.version > version) {
      console.log("自动保存API: 版本冲突", {
        currentVersion: document.version,
        requestVersion: version
      });
      return NextResponse.json(
        { 
          success: false, 
          message: '版本冲突，请刷新获取最新内容', 
          currentVersion: document.version,
          yourVersion: version
        },
        { status: 409 }
      );
    }
    
    // 确保版本号递增
    const newVersion = version ? version + 1 : document.version + 1;
    console.log("自动保存API: 计算新版本号", { newVersion });
    
    // 使用事务确保数据一致性
    try {
      console.log("自动保存API: 开始事务处理");
      const result = await prisma.$transaction(async (tx) => {
        // 更新文档
        const updatedDocument = await tx.document.update({
          where: { id: documentId },
          data: {
            content,
            version: newVersion,
            updatedAt: new Date(),
            updatedById: session.user.id
          }
        });
        
        console.log("自动保存API: 文档更新成功", {
          id: updatedDocument.id,
          version: updatedDocument.version
        });
        
        // 记录自动保存历史（如果需要）
        if (createRevision) {
          await tx.documentRevision.create({
            data: {
              documentId,
              content,
              version: updatedDocument.version,
              createdById: session.user.id,
              message: '自动保存'
            }
          });
          console.log("自动保存API: 创建修订版本成功");
        }
        
        // 记录用户活动
        await tx.activity.create({
          data: {
            userId: session.user.id,
            projectId: projectId,
            type: 'document_updated',
            entityId: documentId,
            data: {
              documentId,
              documentTitle: document.title,
              action: 'autosave'
            }
          }
        });
        console.log("自动保存API: 创建活动记录成功");
        
        return updatedDocument;
      });
      
      // 验证文档是否实际更新
      const verifiedDocument = await prisma.document.findUnique({
        where: { id: documentId }
      });
      
      if (!verifiedDocument || verifiedDocument.version <= document.version) {
        console.error("自动保存API: 验证失败，文档未实际更新");
        return NextResponse.json(
          { 
            success: false, 
            message: '自动保存失败，数据库未更新',
            expected: newVersion,
            actual: verifiedDocument?.version || 'unknown'
          },
          { status: 500 }
        );
      }
      
      console.log("自动保存API: 处理完成，返回成功");
      return NextResponse.json({
        success: true,
        message: '文档已自动保存',
        version: result.version,
        updatedAt: result.updatedAt
      });
    } catch (txError) {
      console.error("自动保存API: 事务处理失败", txError);
      return NextResponse.json(
        { 
          success: false, 
          message: '事务处理失败', 
          error: txError instanceof Error ? txError.message : String(txError) 
        },
        { status: 500 }
      );
    }
  } catch (error) {
    console.error('自动保存文档失败:', error);
    return NextResponse.json(
      { success: false, message: '自动保存文档失败', error: String(error) },
      { status: 500 }
    );
  }
} 